home *** CD-ROM | disk | FTP | other *** search
/ Sky at Night 2007 June / SAN CD 6-2007 CD-ROM 25.iso / pc / Software / AstroGrav_Win / Java / jre1.6.0 / lib / rt.jar / javax / swing / RepaintManager.class (.txt) < prev    next >
Encoding:
Java Class File  |  2006-11-29  |  14.7 KB  |  810 lines
  1. package javax.swing;
  2.  
  3. import java.applet.Applet;
  4. import java.awt.Component;
  5. import java.awt.Container;
  6. import java.awt.Dimension;
  7. import java.awt.Frame;
  8. import java.awt.Graphics;
  9. import java.awt.GraphicsConfiguration;
  10. import java.awt.GraphicsDevice;
  11. import java.awt.GraphicsEnvironment;
  12. import java.awt.HeadlessException;
  13. import java.awt.Image;
  14. import java.awt.Rectangle;
  15. import java.awt.Toolkit;
  16. import java.awt.Window;
  17. import java.awt.image.ImageObserver;
  18. import java.awt.image.VolatileImage;
  19. import java.security.AccessController;
  20. import java.util.ArrayList;
  21. import java.util.HashMap;
  22. import java.util.IdentityHashMap;
  23. import java.util.Iterator;
  24. import java.util.LinkedList;
  25. import java.util.List;
  26. import java.util.Map;
  27. import sun.awt.AppContext;
  28. import sun.awt.SunToolkit;
  29. import sun.java2d.SunGraphicsEnvironment;
  30. import sun.security.action.GetPropertyAction;
  31.  
  32. public class RepaintManager {
  33.    static final boolean HANDLE_TOP_LEVEL_PAINT;
  34.    private static final short BUFFER_STRATEGY_NOT_SPECIFIED = 0;
  35.    private static final short BUFFER_STRATEGY_SPECIFIED_ON = 1;
  36.    private static final short BUFFER_STRATEGY_SPECIFIED_OFF = 2;
  37.    private static final short BUFFER_STRATEGY_TYPE;
  38.    private Map<GraphicsConfiguration, VolatileImage> volatileMap;
  39.    private Map<Container, Rectangle> hwDirtyComponents;
  40.    private Map<Container, Rectangle> tmpHWDirtyComponents;
  41.    private Map<Component, Rectangle> dirtyComponents;
  42.    private Map<Component, Rectangle> tmpDirtyComponents;
  43.    private List<Component> invalidComponents;
  44.    private List<Runnable> runnableList;
  45.    boolean doubleBufferingEnabled;
  46.    private Dimension doubleBufferMaxSize;
  47.    DoubleBufferInfo standardDoubleBuffer;
  48.    private PaintManager paintManager;
  49.    private static final Object repaintManagerKey = RepaintManager.class;
  50.    static boolean volatileImageBufferEnabled = true;
  51.    private static boolean nativeDoubleBuffering;
  52.    private static final int VOLATILE_LOOP_MAX = 2;
  53.    private int paintDepth;
  54.    private short bufferStrategyType;
  55.    private boolean painting;
  56.    private JComponent repaintRoot;
  57.    private Thread paintThread;
  58.    Rectangle tmp;
  59.  
  60.    public static RepaintManager currentManager(Component var0) {
  61.       return currentManager(AppContext.getAppContext());
  62.    }
  63.  
  64.    static RepaintManager currentManager(AppContext var0) {
  65.       RepaintManager var1 = (RepaintManager)var0.get(repaintManagerKey);
  66.       if (var1 == null) {
  67.          var1 = new RepaintManager(BUFFER_STRATEGY_TYPE);
  68.          var0.put(repaintManagerKey, var1);
  69.       }
  70.  
  71.       return var1;
  72.    }
  73.  
  74.    public static RepaintManager currentManager(JComponent var0) {
  75.       return currentManager((Component)var0);
  76.    }
  77.  
  78.    public static void setCurrentManager(RepaintManager var0) {
  79.       if (var0 != null) {
  80.          SwingUtilities.appContextPut(repaintManagerKey, var0);
  81.       } else {
  82.          SwingUtilities.appContextRemove(repaintManagerKey);
  83.       }
  84.  
  85.    }
  86.  
  87.    public RepaintManager() {
  88.       this((short)2);
  89.    }
  90.  
  91.    private RepaintManager(short var1) {
  92.       this.volatileMap = new HashMap(1);
  93.       this.doubleBufferingEnabled = true;
  94.       this.paintDepth = 0;
  95.       this.tmp = new Rectangle();
  96.       this.doubleBufferingEnabled = !nativeDoubleBuffering;
  97.       synchronized(this) {
  98.          this.dirtyComponents = new IdentityHashMap();
  99.          this.tmpDirtyComponents = new IdentityHashMap();
  100.          this.bufferStrategyType = var1;
  101.          this.hwDirtyComponents = new IdentityHashMap();
  102.          this.tmpHWDirtyComponents = new IdentityHashMap();
  103.       }
  104.    }
  105.  
  106.    private void displayChanged() {
  107.       this.clearImages();
  108.    }
  109.  
  110.    public synchronized void addInvalidComponent(JComponent var1) {
  111.       Object var2 = null;
  112.       Object var3 = var1;
  113.  
  114.       while(true) {
  115.          if (var3 != null) {
  116.             if (var3 instanceof CellRendererPane || ((Component)var3).getPeer() == null) {
  117.                return;
  118.             }
  119.  
  120.             if (!(var3 instanceof JComponent) || !((JComponent)var3).isValidateRoot()) {
  121.                var3 = ((Component)var3).getParent();
  122.                continue;
  123.             }
  124.  
  125.             var2 = var3;
  126.          }
  127.  
  128.          if (var2 == null) {
  129.             return;
  130.          }
  131.  
  132.          var3 = null;
  133.          Object var4 = var2;
  134.  
  135.          while(true) {
  136.             if (var4 != null) {
  137.                if (!((Component)var4).isVisible() || ((Component)var4).getPeer() == null) {
  138.                   return;
  139.                }
  140.  
  141.                if (!(var4 instanceof Window) && !(var4 instanceof Applet)) {
  142.                   var4 = ((Component)var4).getParent();
  143.                   continue;
  144.                }
  145.  
  146.                var3 = var4;
  147.             }
  148.  
  149.             if (var3 == null) {
  150.                return;
  151.             }
  152.  
  153.             if (this.invalidComponents == null) {
  154.                this.invalidComponents = new ArrayList();
  155.             } else {
  156.                int var7 = this.invalidComponents.size();
  157.  
  158.                for(int var5 = 0; var5 < var7; ++var5) {
  159.                   if (var2 == this.invalidComponents.get(var5)) {
  160.                      return;
  161.                   }
  162.                }
  163.             }
  164.  
  165.             this.invalidComponents.add(var2);
  166.             SystemEventQueueUtilities.queueComponentWorkRequest((Component)var3);
  167.             return;
  168.          }
  169.       }
  170.    }
  171.  
  172.    public synchronized void removeInvalidComponent(JComponent var1) {
  173.       if (this.invalidComponents != null) {
  174.          int var2 = this.invalidComponents.indexOf(var1);
  175.          if (var2 != -1) {
  176.             this.invalidComponents.remove(var2);
  177.          }
  178.       }
  179.  
  180.    }
  181.  
  182.    private void addDirtyRegion0(Container var1, int var2, int var3, int var4, int var5) {
  183.       if (var4 > 0 && var5 > 0 && var1 != null) {
  184.          if (var1.getWidth() > 0 && var1.getHeight() > 0) {
  185.             if (!this.extendDirtyRegion(var1, var2, var3, var4, var5)) {
  186.                Container var6 = null;
  187.                Container var7 = var1;
  188.  
  189.                while(true) {
  190.                   if (var7 != null) {
  191.                      if (!var7.isVisible() || var7.getPeer() == null) {
  192.                         return;
  193.                      }
  194.  
  195.                      if (!(var7 instanceof Window) && !(var7 instanceof Applet)) {
  196.                         var7 = var7.getParent();
  197.                         continue;
  198.                      }
  199.  
  200.                      if (var7 instanceof Frame && (((Frame)var7).getExtendedState() & 1) == 1) {
  201.                         return;
  202.                      }
  203.  
  204.                      var6 = var7;
  205.                   }
  206.  
  207.                   if (var6 == null) {
  208.                      return;
  209.                   }
  210.  
  211.                   synchronized(this) {
  212.                      if (this.extendDirtyRegion(var1, var2, var3, var4, var5)) {
  213.                         return;
  214.                      }
  215.  
  216.                      this.dirtyComponents.put(var1, new Rectangle(var2, var3, var4, var5));
  217.                   }
  218.  
  219.                   SystemEventQueueUtilities.queueComponentWorkRequest(var6);
  220.                   return;
  221.                }
  222.             }
  223.          }
  224.       }
  225.    }
  226.  
  227.    public void addDirtyRegion(JComponent var1, int var2, int var3, int var4, int var5) {
  228.       this.addDirtyRegion0(var1, var2, var3, var4, var5);
  229.    }
  230.  
  231.    public void addDirtyRegion(Window var1, int var2, int var3, int var4, int var5) {
  232.       this.addDirtyRegion0(var1, var2, var3, var4, var5);
  233.    }
  234.  
  235.    public void addDirtyRegion(Applet var1, int var2, int var3, int var4, int var5) {
  236.       this.addDirtyRegion0(var1, var2, var3, var4, var5);
  237.    }
  238.  
  239.    void scheduleHeavyWeightPaints() {
  240.       Map var1;
  241.       synchronized(this) {
  242.          if (this.hwDirtyComponents.size() == 0) {
  243.             return;
  244.          }
  245.  
  246.          var1 = this.hwDirtyComponents;
  247.          this.hwDirtyComponents = this.tmpHWDirtyComponents;
  248.          this.tmpHWDirtyComponents = var1;
  249.          this.hwDirtyComponents.clear();
  250.       }
  251.  
  252.       for(Container var3 : var1.keySet()) {
  253.          Rectangle var4 = (Rectangle)var1.get(var3);
  254.          if (var3 instanceof Window) {
  255.             this.addDirtyRegion((Window)var3, var4.x, var4.y, var4.width, var4.height);
  256.          } else if (var3 instanceof Applet) {
  257.             this.addDirtyRegion((Applet)var3, var4.x, var4.y, var4.width, var4.height);
  258.          } else {
  259.             this.addDirtyRegion0(var3, var4.x, var4.y, var4.width, var4.height);
  260.          }
  261.       }
  262.  
  263.    }
  264.  
  265.    void nativeAddDirtyRegion(AppContext var1, Container var2, int var3, int var4, int var5, int var6) {
  266.       if (var5 > 0 && var6 > 0) {
  267.          synchronized(this) {
  268.             Rectangle var8 = (Rectangle)this.hwDirtyComponents.get(var2);
  269.             if (var8 == null) {
  270.                this.hwDirtyComponents.put(var2, new Rectangle(var3, var4, var5, var6));
  271.             } else {
  272.                this.hwDirtyComponents.put(var2, SwingUtilities.computeUnion(var3, var4, var5, var6, var8));
  273.             }
  274.          }
  275.  
  276.          SystemEventQueueUtilities.queueComponentWorkRequest(var2, var1);
  277.       }
  278.  
  279.    }
  280.  
  281.    void nativeQueueSurfaceDataRunnable(AppContext var1, Component var2, Runnable var3) {
  282.       synchronized(this) {
  283.          if (this.runnableList == null) {
  284.             this.runnableList = new LinkedList();
  285.          }
  286.  
  287.          this.runnableList.add(var3);
  288.       }
  289.  
  290.       SystemEventQueueUtilities.queueComponentWorkRequest(var2, var1);
  291.    }
  292.  
  293.    private synchronized boolean extendDirtyRegion(Component var1, int var2, int var3, int var4, int var5) {
  294.       Rectangle var6 = (Rectangle)this.dirtyComponents.get(var1);
  295.       if (var6 != null) {
  296.          SwingUtilities.computeUnion(var2, var3, var4, var5, var6);
  297.          return true;
  298.       } else {
  299.          return false;
  300.       }
  301.    }
  302.  
  303.    public Rectangle getDirtyRegion(JComponent var1) {
  304.       Object var2 = null;
  305.       Rectangle var6;
  306.       synchronized(this) {
  307.          var6 = (Rectangle)this.dirtyComponents.get(var1);
  308.       }
  309.  
  310.       return var6 == null ? new Rectangle(0, 0, 0, 0) : new Rectangle(var6);
  311.    }
  312.  
  313.    public void markCompletelyDirty(JComponent var1) {
  314.       this.addDirtyRegion((JComponent)var1, 0, 0, Integer.MAX_VALUE, Integer.MAX_VALUE);
  315.    }
  316.  
  317.    public void markCompletelyClean(JComponent var1) {
  318.       synchronized(this) {
  319.          this.dirtyComponents.remove(var1);
  320.       }
  321.    }
  322.  
  323.    public boolean isCompletelyDirty(JComponent var1) {
  324.       Rectangle var2 = this.getDirtyRegion(var1);
  325.       return var2.width == Integer.MAX_VALUE && var2.height == Integer.MAX_VALUE;
  326.    }
  327.  
  328.    public void validateInvalidComponents() {
  329.       List var1;
  330.       synchronized(this) {
  331.          if (this.invalidComponents == null) {
  332.             return;
  333.          }
  334.  
  335.          var1 = this.invalidComponents;
  336.          this.invalidComponents = null;
  337.       }
  338.  
  339.       int var2 = var1.size();
  340.  
  341.       for(int var3 = 0; var3 < var2; ++var3) {
  342.          ((Component)var1.get(var3)).validate();
  343.       }
  344.  
  345.    }
  346.  
  347.    void seqPaintDirtyRegions() {
  348.       Map var1;
  349.       List var2;
  350.       synchronized(this) {
  351.          var1 = this.dirtyComponents;
  352.          var2 = this.runnableList;
  353.          this.runnableList = null;
  354.       }
  355.  
  356.       if (var2 != null) {
  357.          for(Runnable var4 : var2) {
  358.             var4.run();
  359.          }
  360.       }
  361.  
  362.       this.paintDirtyRegions();
  363.       if (var1.size() > 0) {
  364.          this.paintDirtyRegions(var1);
  365.       }
  366.  
  367.    }
  368.  
  369.    public void paintDirtyRegions() {
  370.       synchronized(this) {
  371.          Map var2 = this.tmpDirtyComponents;
  372.          this.tmpDirtyComponents = this.dirtyComponents;
  373.          this.dirtyComponents = var2;
  374.          this.dirtyComponents.clear();
  375.       }
  376.  
  377.       this.paintDirtyRegions(this.tmpDirtyComponents);
  378.    }
  379.  
  380.    private void paintDirtyRegions(Map<Component, Rectangle> var1) {
  381.       int var3 = var1.size();
  382.       if (var3 != 0) {
  383.          byte var7 = 0;
  384.          byte var8 = 0;
  385.          int var9 = 0;
  386.          int var10 = 0;
  387.          ArrayList var4 = new ArrayList(var3);
  388.  
  389.          for(Component var13 : var1.keySet()) {
  390.             this.collectDirtyComponents(var1, var13, var4);
  391.          }
  392.  
  393.          var3 = var4.size();
  394.          this.painting = true;
  395.  
  396.          try {
  397.             for(int var2 = 0; var2 < var3; ++var2) {
  398.                Component var5 = (Component)var4.get(var2);
  399.                Rectangle var6 = (Rectangle)var1.get(var5);
  400.                var9 = var5.getHeight();
  401.                var10 = var5.getWidth();
  402.                SwingUtilities.computeIntersection(var7, var8, var10, var9, var6);
  403.                if (var5 instanceof JComponent) {
  404.                   ((JComponent)var5).paintImmediately(var6.x, var6.y, var6.width, var6.height);
  405.                } else if (var5.isShowing()) {
  406.                   Graphics var25 = JComponent.safelyGetGraphics(var5, var5);
  407.                   if (var25 != null) {
  408.                      var25.setClip(var6.x, var6.y, var6.width, var6.height);
  409.  
  410.                      try {
  411.                         var5.paint(var25);
  412.                      } finally {
  413.                         var25.dispose();
  414.                      }
  415.                   }
  416.                }
  417.  
  418.                if (this.repaintRoot != null) {
  419.                   this.adjustRoots(this.repaintRoot, var4, var2 + 1);
  420.                   var3 = var4.size();
  421.                   this.paintManager.isRepaintingRoot = true;
  422.                   this.repaintRoot.paintImmediately(0, 0, this.repaintRoot.getWidth(), this.repaintRoot.getHeight());
  423.                   this.paintManager.isRepaintingRoot = false;
  424.                   this.repaintRoot = null;
  425.                }
  426.             }
  427.          } finally {
  428.             this.painting = false;
  429.          }
  430.  
  431.          var1.clear();
  432.       }
  433.    }
  434.  
  435.    private void adjustRoots(JComponent var1, List<Component> var2, int var3) {
  436.       for(int var4 = var2.size() - 1; var4 >= var3; --var4) {
  437.          Object var5;
  438.          for(var5 = (Component)var2.get(var4); var5 != var1 && var5 != null && var5 instanceof JComponent; var5 = ((Component)var5).getParent()) {
  439.          }
  440.  
  441.          if (var5 == var1) {
  442.             var2.remove(var4);
  443.          }
  444.       }
  445.  
  446.    }
  447.  
  448.    void collectDirtyComponents(Map<Component, Rectangle> var1, Component var2, List<Component> var3) {
  449.       Object var9 = var2;
  450.       Object var8 = var2;
  451.       int var12 = var2.getX();
  452.       int var13 = var2.getY();
  453.       int var14 = var2.getWidth();
  454.       int var15 = var2.getHeight();
  455.       int var6 = 0;
  456.       int var4 = 0;
  457.       int var7 = 0;
  458.       int var5 = 0;
  459.       this.tmp.setBounds((Rectangle)var1.get(var2));
  460.       SwingUtilities.computeIntersection(0, 0, var14, var15, this.tmp);
  461.       if (!this.tmp.isEmpty()) {
  462.          while(var8 instanceof JComponent) {
  463.             Container var10 = ((Component)var8).getParent();
  464.             if (var10 == null) {
  465.                break;
  466.             }
  467.  
  468.             var8 = var10;
  469.             var4 += var12;
  470.             var5 += var13;
  471.             this.tmp.setLocation(this.tmp.x + var12, this.tmp.y + var13);
  472.             var12 = ((Component)var10).getX();
  473.             var13 = ((Component)var10).getY();
  474.             var14 = ((Component)var10).getWidth();
  475.             var15 = ((Component)var10).getHeight();
  476.             this.tmp = SwingUtilities.computeIntersection(0, 0, var14, var15, this.tmp);
  477.             if (this.tmp.isEmpty()) {
  478.                return;
  479.             }
  480.  
  481.             if (var1.get(var10) != null) {
  482.                var9 = var10;
  483.                var6 = var4;
  484.                var7 = var5;
  485.             }
  486.          }
  487.  
  488.          if (var2 != var9) {
  489.             this.tmp.setLocation(this.tmp.x + var6 - var4, this.tmp.y + var7 - var5);
  490.             Rectangle var16 = (Rectangle)var1.get(var9);
  491.             SwingUtilities.computeUnion(this.tmp.x, this.tmp.y, this.tmp.width, this.tmp.height, var16);
  492.          }
  493.  
  494.          if (!var3.contains(var9)) {
  495.             var3.add(var9);
  496.          }
  497.  
  498.       }
  499.    }
  500.  
  501.    public synchronized String toString() {
  502.       StringBuffer var1 = new StringBuffer();
  503.       if (this.dirtyComponents != null) {
  504.          var1.append("" + this.dirtyComponents);
  505.       }
  506.  
  507.       return var1.toString();
  508.    }
  509.  
  510.    public Image getOffscreenBuffer(Component var1, int var2, int var3) {
  511.       return this._getOffscreenBuffer(var1, var2, var3);
  512.    }
  513.  
  514.    public Image getVolatileOffscreenBuffer(Component var1, int var2, int var3) {
  515.       GraphicsConfiguration var4 = var1.getGraphicsConfiguration();
  516.       if (var4 == null) {
  517.          var4 = GraphicsEnvironment.getLocalGraphicsEnvironment().getDefaultScreenDevice().getDefaultConfiguration();
  518.       }
  519.  
  520.       Dimension var5 = this.getDoubleBufferMaximumSize();
  521.       int var6 = var2 < 1 ? 1 : (var2 > var5.width ? var5.width : var2);
  522.       int var7 = var3 < 1 ? 1 : (var3 > var5.height ? var5.height : var3);
  523.       VolatileImage var8 = (VolatileImage)this.volatileMap.get(var4);
  524.       if (var8 == null || var8.getWidth() < var6 || var8.getHeight() < var7) {
  525.          if (var8 != null) {
  526.             var8.flush();
  527.          }
  528.  
  529.          var8 = var4.createCompatibleVolatileImage(var6, var7);
  530.          this.volatileMap.put(var4, var8);
  531.       }
  532.  
  533.       return var8;
  534.    }
  535.  
  536.    private Image _getOffscreenBuffer(Component var1, int var2, int var3) {
  537.       Dimension var4 = this.getDoubleBufferMaximumSize();
  538.       Object var5 = null;
  539.       if (this.standardDoubleBuffer == null) {
  540.          this.standardDoubleBuffer = new DoubleBufferInfo(this, (1)null);
  541.       }
  542.  
  543.       DoubleBufferInfo var9 = this.standardDoubleBuffer;
  544.       int var6 = var2 < 1 ? 1 : (var2 > var4.width ? var4.width : var2);
  545.       int var7 = var3 < 1 ? 1 : (var3 > var4.height ? var4.height : var3);
  546.       if (var9.needsReset || var9.image != null && (var9.size.width < var6 || var9.size.height < var7)) {
  547.          var9.needsReset = false;
  548.          if (var9.image != null) {
  549.             var9.image.flush();
  550.             var9.image = null;
  551.          }
  552.  
  553.          var6 = Math.max(var9.size.width, var6);
  554.          var7 = Math.max(var9.size.height, var7);
  555.       }
  556.  
  557.       Image var8 = var9.image;
  558.       if (var9.image == null) {
  559.          var8 = var1.createImage(var6, var7);
  560.          var9.size = new Dimension(var6, var7);
  561.          if (var1 instanceof JComponent) {
  562.             ((JComponent)var1).setCreatedDoubleBuffer(true);
  563.             var9.image = var8;
  564.          }
  565.       }
  566.  
  567.       return var8;
  568.    }
  569.  
  570.    public void setDoubleBufferMaximumSize(Dimension var1) {
  571.       this.doubleBufferMaxSize = var1;
  572.       if (this.doubleBufferMaxSize == null) {
  573.          this.clearImages();
  574.       } else {
  575.          this.clearImages(var1.width, var1.height);
  576.       }
  577.  
  578.    }
  579.  
  580.    private void clearImages() {
  581.       this.clearImages(0, 0);
  582.    }
  583.  
  584.    private void clearImages(int var1, int var2) {
  585.       if (this.standardDoubleBuffer != null && this.standardDoubleBuffer.image != null && (this.standardDoubleBuffer.image.getWidth((ImageObserver)null) > var1 || this.standardDoubleBuffer.image.getHeight((ImageObserver)null) > var2)) {
  586.          this.standardDoubleBuffer.image.flush();
  587.          this.standardDoubleBuffer.image = null;
  588.       }
  589.  
  590.       Iterator var3 = this.volatileMap.keySet().iterator();
  591.  
  592.       while(var3.hasNext()) {
  593.          GraphicsConfiguration var4 = (GraphicsConfiguration)var3.next();
  594.          VolatileImage var5 = (VolatileImage)this.volatileMap.get(var4);
  595.          if (var5.getWidth() > var1 || var5.getHeight() > var2) {
  596.             var5.flush();
  597.             var3.remove();
  598.          }
  599.       }
  600.  
  601.    }
  602.  
  603.    public Dimension getDoubleBufferMaximumSize() {
  604.       if (this.doubleBufferMaxSize == null) {
  605.          try {
  606.             Rectangle var1 = new Rectangle();
  607.             GraphicsEnvironment var2 = GraphicsEnvironment.getLocalGraphicsEnvironment();
  608.  
  609.             for(GraphicsDevice var6 : var2.getScreenDevices()) {
  610.                GraphicsConfiguration var7 = var6.getDefaultConfiguration();
  611.                var1 = var1.union(var7.getBounds());
  612.             }
  613.  
  614.             this.doubleBufferMaxSize = new Dimension(var1.width, var1.height);
  615.          } catch (HeadlessException var8) {
  616.             this.doubleBufferMaxSize = new Dimension(Integer.MAX_VALUE, Integer.MAX_VALUE);
  617.          }
  618.       }
  619.  
  620.       return this.doubleBufferMaxSize;
  621.    }
  622.  
  623.    public void setDoubleBufferingEnabled(boolean var1) {
  624.       this.doubleBufferingEnabled = var1;
  625.       PaintManager var2 = this.getPaintManager();
  626.       if (!var1 && var2.getClass() != PaintManager.class) {
  627.          this.setPaintManager(new PaintManager());
  628.       }
  629.  
  630.    }
  631.  
  632.    public boolean isDoubleBufferingEnabled() {
  633.       return this.doubleBufferingEnabled;
  634.    }
  635.  
  636.    void resetDoubleBuffer() {
  637.       if (this.standardDoubleBuffer != null) {
  638.          this.standardDoubleBuffer.needsReset = true;
  639.       }
  640.  
  641.    }
  642.  
  643.    void resetVolatileDoubleBuffer(GraphicsConfiguration var1) {
  644.       Image var2 = (Image)this.volatileMap.remove(var1);
  645.       if (var2 != null) {
  646.          var2.flush();
  647.       }
  648.  
  649.    }
  650.  
  651.    boolean useVolatileDoubleBuffer() {
  652.       return volatileImageBufferEnabled;
  653.    }
  654.  
  655.    private synchronized boolean isPaintingThread() {
  656.       return Thread.currentThread() == this.paintThread;
  657.    }
  658.  
  659.    void paint(JComponent var1, JComponent var2, Graphics var3, int var4, int var5, int var6, int var7) {
  660.       PaintManager var8 = this.getPaintManager();
  661.       if (!this.isPaintingThread() && var8.getClass() != PaintManager.class) {
  662.          var8 = new PaintManager();
  663.          var8.repaintManager = this;
  664.       }
  665.  
  666.       if (!var8.paint(var1, var2, var3, var4, var5, var6, var7)) {
  667.          var3.setClip(var4, var5, var6, var7);
  668.          var1.paintToOffscreen(var3, var4, var5, var6, var7, var4 + var6, var5 + var7);
  669.       }
  670.  
  671.    }
  672.  
  673.    void copyArea(JComponent var1, Graphics var2, int var3, int var4, int var5, int var6, int var7, int var8, boolean var9) {
  674.       this.getPaintManager().copyArea(var1, var2, var3, var4, var5, var6, var7, var8, var9);
  675.    }
  676.  
  677.    void beginPaint() {
  678.       boolean var1 = false;
  679.       int var2 = 0;
  680.       Thread var3 = Thread.currentThread();
  681.       synchronized(this) {
  682.          var2 = this.paintDepth;
  683.          if (this.paintThread != null && var3 != this.paintThread) {
  684.             var1 = true;
  685.          } else {
  686.             this.paintThread = var3;
  687.             ++this.paintDepth;
  688.          }
  689.       }
  690.  
  691.       if (!var1 && var2 == 0) {
  692.          this.getPaintManager().beginPaint();
  693.       }
  694.  
  695.    }
  696.  
  697.    void endPaint() {
  698.       if (this.isPaintingThread()) {
  699.          PaintManager var1 = null;
  700.          synchronized(this) {
  701.             if (--this.paintDepth == 0) {
  702.                var1 = this.getPaintManager();
  703.             }
  704.          }
  705.  
  706.          if (var1 != null) {
  707.             var1.endPaint();
  708.             synchronized(this) {
  709.                this.paintThread = null;
  710.             }
  711.          }
  712.       }
  713.  
  714.    }
  715.  
  716.    boolean show(Container var1, int var2, int var3, int var4, int var5) {
  717.       return this.getPaintManager().show(var1, var2, var3, var4, var5);
  718.    }
  719.  
  720.    void doubleBufferingChanged(JRootPane var1) {
  721.       this.getPaintManager().doubleBufferingChanged(var1);
  722.    }
  723.  
  724.    void setPaintManager(PaintManager var1) {
  725.       if (var1 == null) {
  726.          var1 = new PaintManager();
  727.       }
  728.  
  729.       PaintManager var2;
  730.       synchronized(this) {
  731.          var2 = this.paintManager;
  732.          this.paintManager = var1;
  733.          var1.repaintManager = this;
  734.       }
  735.  
  736.       if (var2 != null) {
  737.          var2.dispose();
  738.       }
  739.  
  740.    }
  741.  
  742.    private synchronized PaintManager getPaintManager() {
  743.       if (this.paintManager == null) {
  744.          BufferStrategyPaintManager var1 = null;
  745.          if (this.doubleBufferingEnabled && !nativeDoubleBuffering) {
  746.             switch (this.bufferStrategyType) {
  747.                case 0:
  748.                   if (((SunToolkit)Toolkit.getDefaultToolkit()).useBufferPerWindow()) {
  749.                      var1 = new BufferStrategyPaintManager();
  750.                   }
  751.                   break;
  752.                case 1:
  753.                   var1 = new BufferStrategyPaintManager();
  754.             }
  755.          }
  756.  
  757.          this.setPaintManager(var1);
  758.       }
  759.  
  760.       return this.paintManager;
  761.    }
  762.  
  763.    // $FF: synthetic method
  764.    static JComponent access$200(RepaintManager var0) {
  765.       return var0.repaintRoot;
  766.    }
  767.  
  768.    // $FF: synthetic method
  769.    static boolean access$300(RepaintManager var0) {
  770.       return var0.painting;
  771.    }
  772.  
  773.    // $FF: synthetic method
  774.    static JComponent access$202(RepaintManager var0, JComponent var1) {
  775.       return var0.repaintRoot = var1;
  776.    }
  777.  
  778.    // $FF: synthetic method
  779.    static void access$500(RepaintManager var0) {
  780.       var0.displayChanged();
  781.    }
  782.  
  783.    static {
  784.       volatileImageBufferEnabled = "true".equals(AccessController.doPrivileged(new GetPropertyAction("swing.volatileImageBufferEnabled", "true")));
  785.       boolean var0 = GraphicsEnvironment.isHeadless();
  786.       if (volatileImageBufferEnabled && var0) {
  787.          volatileImageBufferEnabled = false;
  788.       }
  789.  
  790.       nativeDoubleBuffering = "true".equals(AccessController.doPrivileged(new GetPropertyAction("awt.nativeDoubleBuffering")));
  791.       String var1 = (String)AccessController.doPrivileged(new GetPropertyAction("swing.bufferPerWindow"));
  792.       if (var0) {
  793.          BUFFER_STRATEGY_TYPE = 2;
  794.       } else if (var1 == null) {
  795.          BUFFER_STRATEGY_TYPE = 0;
  796.       } else if ("true".equals(var1)) {
  797.          BUFFER_STRATEGY_TYPE = 1;
  798.       } else {
  799.          BUFFER_STRATEGY_TYPE = 2;
  800.       }
  801.  
  802.       HANDLE_TOP_LEVEL_PAINT = "true".equals(AccessController.doPrivileged(new GetPropertyAction("swing.handleTopLevelPaint", "true")));
  803.       GraphicsEnvironment var2 = GraphicsEnvironment.getLocalGraphicsEnvironment();
  804.       if (var2 instanceof SunGraphicsEnvironment) {
  805.          ((SunGraphicsEnvironment)var2).addDisplayChangedListener(new DisplayChangedHandler((1)null));
  806.       }
  807.  
  808.    }
  809. }
  810.